home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1997 May / EnigmA AMIGA RUN 18 (1997)(G.R. Edizioni)(IT)[!][issue 1997-05][EAR-CD II].iso / earcd / gfx / fract / lfracs.lha / LFracs-Source.lha / LFracs-Source / GuiFuncs.c next >
C/C++ Source or Header  |  1996-12-27  |  12KB  |  406 lines
  1. /* GuiFuncs.c */
  2.  
  3. #include "StdInc.h"
  4. #include "GuiFuncs.h"
  5.  
  6.  struct GuiMenulist {
  7.                        USHORT             system_id,user_id;
  8.                        GuiFuncptr         func;
  9.                        struct GuiMenulist *next;
  10.                     };
  11.  struct GuiGadlist  {
  12.                        USHORT            ident;
  13.                        struct Gadget     *gadadr;
  14.                        GuiFuncptr        func;
  15.                        struct GuiGadlist *next;
  16.                     };
  17.  
  18.  PRIVATE struct GuiGadlist  *gui_gads  = NULL;
  19.  PRIVATE struct GuiMenulist *gui_menus = NULL;
  20.  
  21.  PRIVATE SHORT menu_anzahl = 0;
  22.  PRIVATE SHORT GapX=0,GapY=0,BaseX=0,BaseY=0,LastW=0,LastH=0;
  23.  
  24.  PRIVATE APTR vi_info = NULL;
  25.  PRIVATE struct Screen *pscreen = NULL;
  26.  PRIVATE struct RastPort *scr_rport = NULL;
  27.  PRIVATE struct Requester *busyreq = NULL;
  28.  PRIVATE struct IntuiMessage *msg = NULL;
  29.  
  30.  PRIVATE LONG FontWidth,FontHeight;
  31.  PRIVATE struct Catalog *cat = NULL;
  32.  PRIVATE char **default_catstr = NULL;
  33.  
  34. void start_GUI(void)
  35. {
  36.  struct DrawInfo *draw_info = NULL;
  37.  struct Rectangle rect;
  38.  ULONG scr_modeID;
  39.  
  40.    pscreen    = (struct Screen *) LockPubScreen(NULL);
  41.    scr_rport  = &(pscreen->RastPort);
  42.    vi_info    = (APTR) GetVisualInfoA(pscreen,NULL);
  43.    scr_modeID = GetVPModeID(&pscreen->ViewPort);
  44.    draw_info  = (struct DrawInfo *) GetScreenDrawInfo(pscreen);
  45.  
  46.    QueryOverscan(scr_modeID,&rect,OSCAN_TEXT);
  47.    OScanWidth  = rect.MaxX - rect.MinX + 1;
  48.    OScanHeight = rect.MaxY - rect.MinY + 1;
  49.  
  50.    FontWidth   = (LONG) draw_info->dri_Font->tf_XSize;
  51.    FontHeight  = (LONG) draw_info->dri_Font->tf_YSize;
  52.    XScale      = (SHORT) (draw_info->dri_Resolution).X / 11;
  53.    YScale      = (SHORT) (draw_info->dri_Resolution).Y / 11;
  54.    Scale       = YScale/XScale;
  55.  
  56.    FreeScreenDrawInfo(pscreen,draw_info);
  57. }
  58.  
  59. void loop_GUI(struct Window *win)
  60. {
  61.  APTR   iadr;
  62.  ULONG  class;
  63.  USHORT code,gad_id,menu_id;
  64.  struct GuiMenulist *mlist;
  65.  struct GuiGadlist *glist;
  66.  struct Requester *req;
  67.  
  68.   FOREVER {
  69.      Wait(1L<<win->UserPort->mp_SigBit);
  70.     while(msg = (struct IntuiMessage *) GetMsg(win->UserPort))
  71.       while(msg) {
  72.          class = msg->Class;
  73.          code  = msg->Code;
  74.          iadr  = msg->IAddress;
  75.          ReplyMsg((struct Message *)msg); msg=NULL;
  76.         switch(class) {
  77.           case IDCMP_GADGETUP: gad_id = ((struct Gadget *) iadr)->GadgetID;
  78.                                for(glist=gui_gads;glist;glist=glist->next)
  79.                                if(gad_id==glist->ident) {
  80.                                  if(glist->func) (*(glist->func))(gad_id,IDCMP_GADGETUP);
  81.                                  break;
  82.                                }
  83.                                break;
  84.           case IDCMP_MENUPICK: menu_id = SHIFTMENU(MENUNUM(code)) |
  85.                                          SHIFTITEM(ITEMNUM(code));
  86.                                for(mlist=gui_menus;mlist;mlist=mlist->next)
  87.                                if(menu_id==mlist->system_id) {
  88.                                  if(mlist->func) (*(mlist->func))(mlist->user_id,IDCMP_MENUPICK);
  89.                                  break;
  90.                                }
  91.                                break;
  92.           case IDCMP_NEWSIZE: if(req=win->FirstRequest)
  93.                                 if(req->ReqLayer)
  94.                                    DrawBevelBox(req->ReqLayer->rp,
  95.                                        0,0,req->Width,req->Height,
  96.                                        GT_VisualInfo,vi_info,TAG_DONE);
  97.                               break;
  98.           case IDCMP_CLOSEWINDOW: return(); break;
  99.         }
  100.       }
  101.   }
  102. }
  103.  
  104. struct IntuiMessage *read_message(struct Window *win)
  105. {return (msg = (struct IntuiMessage *) GetMsg(win->UserPort));}
  106.  
  107. void destroy_GuiGadlist(struct GuiGadlist *glist)
  108. {
  109.   if (glist) {destroy_GuiGadlist(glist->next); free(glist);}
  110. }
  111.  
  112. void destroy_GuiMenulist(struct GuiMenulist *mlist)
  113. {
  114.   if (mlist) {destroy_GuiMenulist(mlist->next); free(mlist);}
  115. }
  116.  
  117. void end_GUI(void)
  118. {
  119.    FreeVisualInfo(vi_info);
  120.    UnlockPubScreen(NULL,pscreen);
  121.  
  122.    destroy_GuiGadlist(gui_gads);
  123.    destroy_GuiMenulist(gui_menus);
  124. }
  125.  
  126. void fill_tag(struct TagItem *item,Tag tag,ULONG data)
  127. {
  128.    item->ti_Tag  = tag;
  129.    item->ti_Data = data;
  130. }
  131.  
  132. SHORT fwidth(SHORT n)
  133. {return (SHORT) (FontWidth*n);}
  134.  
  135. SHORT fheight(SHORT n)
  136. {return (SHORT) (FontHeight*n);}
  137.  
  138. void set_gaps(SHORT xgap, SHORT ygap)
  139. {GapX=xgap; GapY=ygap;}
  140.  
  141. void set_base(SHORT x, SHORT y)
  142. {BaseX=x; BaseY=y; LastW=0; LastH=0;}
  143.  
  144. SHORT relX(SHORT z)
  145. {return (SHORT) (BaseX+(LastW+GapX)*z);}
  146.  
  147. SHORT relY(SHORT z)
  148. {return (SHORT) (BaseY+(LastH+GapY)*z);}
  149.  
  150. SHORT tlength(char *text)
  151. {return (SHORT) TextLength(scr_rport,(UBYTE *)text,strlen(text))+8;}
  152.  
  153. struct IntuiText *make_text(char *text, SHORT left, SHORT top,
  154.                             UBYTE fpen, struct IntuiText *next)
  155. {
  156.  struct IntuiText *name;
  157.  
  158.    name = (struct IntuiText *) malloc(sizeof(struct IntuiText));
  159.    name->FrontPen =fpen;
  160.    name->BackPen  =(UBYTE)!fpen;
  161.    name->DrawMode =JAM1;
  162.    name->LeftEdge =left;
  163.    name->TopEdge  =top;
  164.    name->ITextFont=NULL;
  165.    name->IText    =(UBYTE *) text;
  166.    name->NextText =next;
  167.  
  168.  return name;
  169. }
  170.  
  171. void destroy_text(struct IntuiText *text)
  172. {
  173.   if(text) {destroy_text(text->NextText); free(text);}
  174. }
  175.  
  176. void append_gad(struct Gadget *gad,USHORT gad_ident,GuiFuncptr fptr)
  177. {
  178.  struct GuiGadlist *new_gad;
  179.  
  180.    new_gad = (struct GuiGadlist *) malloc(sizeof(struct GuiGadlist));
  181.    new_gad->ident = gad_ident; new_gad->gadadr = gad;
  182.    new_gad->next = gui_gads; new_gad->func = fptr;
  183.    gui_gads = new_gad;
  184. }
  185.  
  186. struct Gadget *get_gadadr(USHORT gad_ident)
  187. {
  188.  struct GuiGadlist *list_ptr;
  189.  
  190.   for(list_ptr=gui_gads;list_ptr;list_ptr=list_ptr->next)
  191.     if(list_ptr->ident==gad_ident) return list_ptr->gadadr;
  192.  
  193.  return NULL;
  194. }
  195.  
  196. void make_gadlist(USHORT glist_ident,USHORT contxt_ident)
  197. {
  198.  struct Gadget *glistptr,*contxtgad;
  199.  
  200.    contxtgad = (struct Gadget *) CreateContext(&glistptr);
  201.  
  202.    append_gad(glistptr,glist_ident,NULL);
  203.    append_gad(contxtgad,contxt_ident,NULL);
  204. }
  205.  
  206. void destroy_gadlist(USHORT glist_ident)
  207. {
  208.    FreeGadgets(get_gadadr(glist_ident));
  209. }
  210.  
  211. void make_gadget(USHORT gad_ident,ULONG kind,USHORT act_flags,
  212.                  SHORT posx,SHORT posy,SHORT width,SHORT height,
  213.                  char *title,char *input,SHORT input_length,
  214.                  USHORT prev_ident,GuiFuncptr gfunc)
  215. {
  216.  struct Gadget    *gad;
  217.  struct NewGadget new_gad;
  218.  
  219.    new_gad.ng_LeftEdge   = (WORD)posx;
  220.    new_gad.ng_TopEdge    = (WORD)posy;
  221.    new_gad.ng_Width      = (WORD)width;
  222.    new_gad.ng_Height     = (WORD)height;
  223.    new_gad.ng_GadgetText = (UBYTE *) title;
  224.    new_gad.ng_TextAttr   = pscreen->Font;
  225.    new_gad.ng_GadgetID   = (UWORD)gad_ident;
  226.    new_gad.ng_VisualInfo = vi_info;
  227.    new_gad.ng_UserData   = NULL;
  228.  
  229.   if (kind & STRING_KIND) {
  230.      new_gad.ng_Flags = PLACETEXT_LEFT;
  231.      gad = (struct Gadget *) CreateGadget(kind,get_gadadr(prev_ident),&new_gad,
  232.                                           GTST_String,(ULONG)input,
  233.                                           GTST_MaxChars,(ULONG)input_length,
  234.                                           GA_TabCycle,TRUE,
  235.                                           TAG_DONE);
  236.   }else {
  237.      new_gad.ng_Flags = PLACETEXT_IN;
  238.      gad = (struct Gadget *) CreateGadget(kind,get_gadadr(prev_ident),&new_gad,
  239.                                           TAG_DONE);
  240.   }
  241.  
  242.    gad->Activation |= act_flags;
  243.  
  244.    append_gad(gad,gad_ident,gfunc);
  245.    
  246.    BaseX=posx; BaseY=posy; LastW=width; LastH=height;
  247. }
  248.  
  249. void set_STGADinfo(USHORT gad_ident,UBYTE *info_text)
  250. {
  251.  struct Gadget *gad=NULL;
  252.  struct StringInfo *gad_info=NULL;
  253.  
  254.    gad      = get_gadadr(gad_ident);
  255.    gad_info = (struct StringInfo *) gad->SpecialInfo;
  256.    strcpy((char *)(gad_info->Buffer),(char *)info_text);
  257. }
  258.  
  259. UBYTE *get_STGADinfo(USHORT gad_ident)
  260. {
  261.  struct Gadget *gad=NULL;
  262.  struct StringInfo *gad_info=NULL;
  263.  
  264.    gad      = get_gadadr(gad_ident);
  265.    gad_info = (struct StringInfo *) gad->SpecialInfo;
  266.  
  267.  return gad_info->Buffer;
  268. }
  269.  
  270. void append_menu(USHORT sysid,USHORT uid,GuiFuncptr fptr)
  271. {
  272.  struct GuiMenulist *new_menu;
  273.  
  274.    new_menu = (struct GuiMenulist *) malloc(sizeof(struct GuiMenulist));
  275.    new_menu->system_id = sysid; new_menu->user_id = uid;
  276.    new_menu->next = gui_menus; new_menu->func = fptr;
  277.    gui_menus = new_menu;
  278. }
  279.  
  280. void add_menu(struct Menu **first_menu,char *title,
  281.               SHORT item_anzahl,struct GuiMenudata *itemdata)
  282. {
  283.  struct Menu *menu,*last_menu;
  284.  struct NewMenu *new_menu;
  285.  struct GuiMenudata *mdptr;
  286.  char   *cmdkey;
  287.  COUNT  i;
  288.  
  289.    new_menu = (struct NewMenu *) malloc(sizeof(struct NewMenu)*(item_anzahl+2));
  290.    new_menu[item_anzahl+1].nm_Type    = (UBYTE) NM_END;
  291.    new_menu[item_anzahl+1].nm_Label   = NULL;
  292.    new_menu[item_anzahl+1].nm_CommKey = NULL;                /* Init nm-Array */
  293.   for (i=0;i<=item_anzahl+1;i++) {
  294.      new_menu[i].nm_Flags = 0; new_menu[i].nm_MutualExclude = 0L;
  295.      new_menu[i].nm_UserData = NULL;
  296.   }
  297.  
  298.    new_menu[0].nm_Type    = (UBYTE) NM_TITLE;        /* Load Menu-Title in nm */
  299.    new_menu[0].nm_Label   = (STRPTR) title;
  300.    new_menu[0].nm_CommKey = NULL;
  301.                                                      /* Load Menu-Items in nm */
  302.   for (i=1;i<=item_anzahl;i++) {
  303.      mdptr=&itemdata[i-1];
  304.     for (cmdkey=mdptr->name;*cmdkey!='_' && *cmdkey!=NULL;cmdkey++);
  305.      *cmdkey=NULL; cmdkey++;     /* beende Menüpunkt-Name vor der CmdKey-Info */
  306.      new_menu[i].nm_Type    = (UBYTE) NM_ITEM;
  307.      new_menu[i].nm_Label   = (STRPTR) mdptr->name;
  308.      new_menu[i].nm_CommKey = (STRPTR) cmdkey;
  309.      append_menu(SHIFTMENU(menu_anzahl) | SHIFTITEM(i-1),mdptr->ident,mdptr->func);
  310.   }
  311.  
  312.    menu = (struct Menu *) CreateMenus(new_menu,TAG_DONE);
  313.  
  314.    menu->NextMenu = NULL; free(new_menu);
  315.  
  316.   if (menu_anzahl == 0) *first_menu=menu;
  317.   else {
  318.     for(i=1,last_menu=*first_menu;i<menu_anzahl;i++)
  319.        last_menu = last_menu->NextMenu;
  320.      last_menu->NextMenu = menu;
  321.   }
  322.    menu_anzahl++;
  323. }
  324.  
  325. void init_menu(struct Window *win,struct Menu *menu)
  326. {
  327.    LayoutMenus(menu,vi_info,TAG_DONE);
  328.    SetMenuStrip(win,menu);
  329. }
  330.  
  331. void destroy_menu(struct Window *win)
  332. {
  333.  struct Menu *menu,*menu_ptr;
  334.  
  335.    menu=win->MenuStrip; ClearMenuStrip(win);
  336.   while (menu!=NULL) {
  337.      menu_ptr=menu; menu=menu->NextMenu;
  338.      FreeMenus(menu_ptr);
  339.   }
  340. }
  341.  
  342. void start_busy(struct Window *win)
  343. {
  344.    busyreq = (struct Requester *) malloc(sizeof(struct Requester));
  345.    InitRequester(busyreq); Request(busyreq,win);
  346. }
  347.  
  348. void end_busy(struct Window *win)
  349. {
  350.    EndRequest(busyreq,win); free(busyreq);
  351. }
  352.  
  353. BOOL bool_request(struct Window *win, char *title, char *pos, char *neg)
  354. {
  355.  BOOL result;
  356.  struct IntuiText *title_text,*pos_text,*neg_text;
  357.  
  358.    title_text=make_text(title,20,10,1,NULL);
  359.    pos_text=make_text(pos,0,0,1,NULL); neg_text=make_text(neg,0,0,1,NULL);
  360.    result=AutoRequest(win,title_text,pos_text,neg_text,0,0,0,0);
  361.    free(title_text); free(pos_text); free(neg_text);
  362.  
  363.   return result;
  364. }
  365.  
  366. void make_req(struct Requester *req,
  367.               SHORT left,SHORT top,SHORT width,SHORT height,
  368.               USHORT gad_ident,struct IntuiText *text,UBYTE fill)
  369. {
  370.  struct Gadget *gad;
  371.  
  372.    InitRequester(req);
  373.    req->LeftEdge  = left;
  374.    req->TopEdge   = top;
  375.    req->Width     = width;
  376.    req->Height    = height;
  377.    req->ReqGadget = get_gadadr(gad_ident);
  378.    req->ReqText   = text;
  379.    req->BackFill  = fill;
  380. }
  381.  
  382. void show_req(struct Requester *req,struct Window *win)
  383. {
  384.    Request(req,win);
  385.    DrawBevelBox(req->ReqLayer->rp,
  386.                 0,0,req->Width,req->Height,
  387.                 GT_VisualInfo,vi_info,TAG_DONE);
  388. }
  389.  
  390. void destroy_req(struct Requester *req) {destroy_text(req->ReqText);}
  391.  
  392.  
  393. void open_catalog(char *cat_name,char **default_strings)
  394. {
  395.    if(LocaleBase) cat = OpenCatalog(NULL,(STRPTR)cat_name,TAG_DONE);
  396.    default_catstr = default_strings;
  397. }
  398.  
  399. char *get_catstr(USHORT ident)
  400. {
  401.    if(LocaleBase) return (char *) GetCatalogStr(cat,ident,
  402.                                      (STRPTR)default_catstr[ident]);
  403.    else           return default_catstr[ident];
  404. }
  405.  
  406. void close_catalog(void) {if(cat) CloseCatalog(cat); cat=NULL;}